    use: 'ie.ondevice.objectkit.core';
    Function.implement.preventOverride= true;
    Function.implement
    (
        {
            /**
             * Determine if an object declares all of the public methods
             * declared on this constructors protoype, or in other words,
             * implements the same interface as this constructors prototype.
             * 
             * @param {Object} subject    Any value.
             * @return {Boolean}
             */            
            like: function (subject) 
            {
                if (null == subject)
                    return false;
                    
                var prototype= this.prototype
                ,   accessor;
                
                for (accessor in prototype) 
                {
                    if('function' === typeof prototype[accessor]
                    && 'constructor' !== accessor
                    && '_' !== accessor.charAt(0)
                    && 'function' !== typeof subject[accessor])
                        return false;
                };
                
                return true;
            }
            
            /**
             * Determine if a constructors prototype is a superprototype of this 
             * constructors prototype.
             * 
             * @param {Function} Constructor
             * @return {Boolean}
             */
        ,   isSubclassOf: function (Constructor) 
            {
                if ('function' === typeof Constructor)
                    return Constructor.prototype.isPrototypeOf(this.prototype);
                    
                return false;
            }
            
            /**
             * Determine if this constructors prototype is a superprototype
             * of another.
             * 
             * @param {Function} Constructor
             * @return {Boolean}
             */
        ,   isSuperclassOf: function (Constructor) 
            {
                if ('function' === typeof Constructor)
                    return this.prototype.isPrototypeOf(Constructor.prototype);
                    
                return false;
            }
            
            /**
             * 
             * @param {Number} interval
             * @param {Object} executionScope
             * @param {Object...} arguments
             * @return {Object}
             */
        ,   defer: function (interval, executionScope) 
            {
                // we could have used the closure object pattern here, but this
                // is the cheapest way of implementing defer
                var method= this
                ,   timeoutId
                ,   presetArgs= Array.prototype.slice.call(arguments, 2)
                ,   deferred= 
                    {
                        hasExecuted: false
                    ,   createdOn: Number(new Date())
                    ,   executedOn: -1
                    ,   interval: interval
                    ,   dispose: function () 
                        {
                            clearTimeout(timeoutId);
                            this.execute= method= null;
                        }
                    ,   execute: function () 
                        {
                            deferred.hasExecuted= true;
                            deferred.executedOn= Number(new Date())
                            try 
                            {
                                deferred.result= method.apply(executionScope, presetArgs);
                            }
                            catch (thrown) 
                            {
                                deferred.fault= thrown;
                            }
                            finally 
                            {
                                 deferred.dispose();
                                 if ('function' === typeof deferred.onExecute)
                                    deferred.onExecute(null == deferred.fault);
                            }
                        }
                    }
                ;
                
                timeoutId= setTimeout(deferred.execute, interval);
                return deferred;
            }
        }
    );
